package com.offcn.service.Impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.offcn.mapper.*;
import com.offcn.pojo.*;
import com.offcn.service.SetmealService;
import com.offcn.utils.MessageConstant;
import com.offcn.utils.PageResult;
import com.offcn.utils.QueryPageBean;
import com.offcn.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

import static com.offcn.utils.MessageConstant.DELETE_SETMEAL_SUCCESS;

/**
 * @Author: wy
 * @Date: 2022/8/30 16:34
 */

@Service
@Component
public class SetmealServiceImpl implements SetmealService {

    @Autowired
    private SetmealMapper setmealMapper;

    @Autowired
    private SetmealCheckgroupMapper setmealCheckgroupMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private CheckgroupMapper checkgroupMapper;

    @Autowired
    private CheckgroupCheckitemMapper checkgroupCheckitemMapper;

    @Autowired
    private CheckitemMapper checkitemMapper;



    //添加新增套餐
    @Override
    @Transactional
    public void addSetmeal(Setmeal setmeal, Integer[] checkgroupIds) {
        //先添加 套餐
        setmealMapper.insert(setmeal);
        //子啊添加套餐对应的 检查组信息
        if (checkgroupIds != null) {
            //创建中间表对象
            SetmealCheckgroup setmealCheckgroup = new SetmealCheckgroup();
            //给 中间表的字段进行赋值
            setmealCheckgroup.setSetmealId(setmeal.getId());
            //可能添加的 数据 比较多 我们采取 循环遍历
            for (Integer checkgroupId : checkgroupIds) {
                //给 中间表的字段进行赋值
                setmealCheckgroup.setCheckgroupId(checkgroupId);
                //给数据库中添加数据
                setmealCheckgroupMapper.insert(setmealCheckgroup);
            }
        }

    }

    //分页查询
    @Override
    public PageResult findPage(QueryPageBean queryPageBean) {
        Page<Setmeal> page =
                new Page<>(queryPageBean.getCurrentPage(), queryPageBean.getPageSize());

        LambdaQueryWrapper<Setmeal> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        Page<Setmeal> setmealPage = null;
        if (queryPageBean.getQueryString() != null && queryPageBean.getQueryString() != "") {

            lambdaQueryWrapper.like(Setmeal::getCode, queryPageBean.getQueryString());
            lambdaQueryWrapper.or();
            lambdaQueryWrapper.like(Setmeal::getHelpcode, queryPageBean.getQueryString());
            lambdaQueryWrapper.or();
            lambdaQueryWrapper.like(Setmeal::getName, queryPageBean.getQueryString());
            setmealPage = setmealMapper.selectPage(page, lambdaQueryWrapper);
        } else {
            setmealPage = setmealMapper.selectPage(page, lambdaQueryWrapper);
        }
        PageResult pageResult = new PageResult(page.getTotal(), page.getRecords());
        return pageResult;
    }


    //修改编辑
    @Override
    @Transactional
    public void editSetmeal(Setmeal setmeal, Integer[] checkgroupIds) {
        //1:先去修改套餐组
        setmealMapper.updateById(setmeal);

        //2:修改检查组下的检查项 id
        //第一步：先吧改修改的检查组下原有的 检查项id 删除 随后 在进行添加
        LambdaQueryWrapper<SetmealCheckgroup> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        lambdaQueryWrapper.eq(SetmealCheckgroup::getSetmealId, setmeal.getId());
        setmealCheckgroupMapper.delete(lambdaQueryWrapper);

        //3: 再次进行循环添加
        if (checkgroupIds != null) {
            SetmealCheckgroup setmealCheckgroup = new SetmealCheckgroup();
            setmealCheckgroup.setSetmealId(setmeal.getId());

            //进行循环添加
            for (Integer checkgroupId : checkgroupIds) {
                setmealCheckgroup.setCheckgroupId(checkgroupId);
                setmealCheckgroupMapper.insert(setmealCheckgroup);
            }
        }
    }

    //删除
    @Override
    @Transactional
    public Result deleteInfo(Integer id) {
        Result result = null;
        //1： 先去判断 该套餐 有没有被 预约  预约了 就不能删除 没有预约  在进行删除
        LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<Order>();
        //先查询
        queryWrapper.eq(Order::getSetmealId, id);
        List<Order> orders = orderMapper.selectList(queryWrapper);
        if (orders != null && orders.size() > 0) {
            result = new Result(false, "该套餐已经被预约，责不能进行删除", null);
        } else {
            //先删除  SetmealCheckgroup 里面的 setmealId 这一列
            LambdaQueryWrapper<SetmealCheckgroup> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(SetmealCheckgroup::getSetmealId, id);
            setmealCheckgroupMapper.delete(lambdaQueryWrapper);
            //在删除 Setmeal 里面的
            setmealMapper.deleteById(id);
            result = new Result(true, DELETE_SETMEAL_SUCCESS, null);
        }
        return result;
    }

    //offcnpe_mobile 的查询
    @Override
    public List<Setmeal> getAllSetmeal() {

        return setmealMapper.selectList(null);
    }

    @Override
    public Setmeal findInfoById(Integer id) {

        //先去查 套餐信息
        Setmeal setmeal = setmealMapper.selectById(id);
        /*
        目前我们只是查询到了  套餐信息
        但是 套餐信息里面的 详情 没有查询出来
        我们接下来 需要 去查询 套餐 和 检查 组 的 关联表中的信息
        并且我们只需啊要 查询指定列
         */
        LambdaQueryWrapper<SetmealCheckgroup>
                setmealCheckgroupLambdaQueryWrapper = new LambdaQueryWrapper<>();
        setmealCheckgroupLambdaQueryWrapper.eq(SetmealCheckgroup::getSetmealId, id).
                select(SetmealCheckgroup::getCheckgroupId);

        //通过查询 我么得到 套餐 对应的 检查组的 id
        List<Integer> checkgroupids = setmealCheckgroupMapper.selectObjs(setmealCheckgroupLambdaQueryWrapper)
                .stream().map(o -> (Integer) o).collect(Collectors.toList());
        /*
        我们查询到了 套餐 对应的 检查组下面的信息 ID
        我们更具id 进行查询 检查组 下面的 检查项 信息
         */
        if (checkgroupids != null && checkgroupids.size() > 0) {

            //根据id 查询 对应的检查组信息
            List<Checkgroup> checkgroupList = checkgroupMapper.selectBatchIds(checkgroupids);

            for (Checkgroup checkgroup : checkgroupList) {
                LambdaQueryWrapper<CheckgroupCheckitem>
                        checkgroupCheckitemLambdaQueryWrapper = new LambdaQueryWrapper<CheckgroupCheckitem>();
                checkgroupCheckitemLambdaQueryWrapper.eq(CheckgroupCheckitem::getCheckgroupId, checkgroup.getId())
                        .select(CheckgroupCheckitem::getCheckitemId);
                List<Integer> checkitemids = checkgroupCheckitemMapper.selectObjs(checkgroupCheckitemLambdaQueryWrapper)
                        .stream().map(o -> (Integer) o).collect(Collectors.toList());
                /*
                我们查询到了检查 组 下对应的检查项 id
                 */
                if (checkitemids != null && checkgroupids.size() > 0) {
                    //根据id 我们查询 对应的检查项
                    List<Checkitem> checkitemList = checkitemMapper.selectBatchIds(checkitemids);

                    //最后 我们吧查询到的 集合 放到  检查组中
                    checkgroup.setCheckitems(checkitemList);

                }
            }
            //最后我们吧检查组赋值给套餐
            setmeal.setCheckgroups(checkgroupList);
        }

        return setmeal;
    }
}
